[TH] User improvements | NulledTeam UnderGround

Please note: To upgrade, upload the files and install the new add-on [TH] User improvements, then continue with the uninstallation [KL] User improvements and deleting the files under src / addons / KL / UserImprovements,

changes:

  • Fixed an issue that caused long wait times when many trophies were queued at the same time
  • A trophy progress bar has been added for certain supported criteria
  • Corrected an issue that prevented the trophy category from being deleted.

c # – Existing multi-element payload with EF Core Performance Improvements

I have a .NET CORE EF application that was first set up as a database and is supposed to host a payload containing items to store in my database. Their payloads can be very large and contain several "securities", and each "security" has several "positions / transactions" to be stored in the database. In some cases, the duration of the expiration may increase exponentially, and some of the payloads may take up to 20 minutes. The ultimate goal is to reduce the time it takes to look through and persist in this code. The memory function is not the problem here (afaik). I think the problem is the nested passage of the payload and all their positions. Any help that speeds this up will be welcomed. Here is my calling function:

                private async task Persist (AccPackBody package)
{
bool hasModifications = false, hasErrors = false;
var secGuidsWithPositions = new list();

using (var dbContext = new NewportMasterContext (Configs.MasterDbConnString))
{
dbContext.Database.SetCommandTimeout (300);

foreach (var mappedSecurity in pack.Internal)
{
mappedSecurity.FirmId = pack.FirmId;

SEC_IDENTIFIER existsSecurity = null;
To attempt
{

existsSecurity = wait for TryFindSecId (mappedSecurity, pack.FirmId.Value, dbContext);

}
catch (exception ex)
{
await Logger.Send (LogType.Error, "An error occurred while trying to clone security");
}

if (existsSecurity == null)
{
waitit Logger.Send (pack, LogType.Error, $ "Missing security for: Identifier: {mappedSecurity.IdentifierName} Value: {mappedSecurity.IdentifierValue}, Firm {pack.FirmId}, Currency: {mappedSecurity.Currency}");
throw new LoggedException ();
}
otherwise
{
mappedSecurity.SecurityGuid = existsSecurity.Security_UID;

POSITION[] updatedPositions = null;
if (mappedSecurity.Postitions! = null && mappedSecurity.Postitions.Length> 0)
{



updatedPositions = HandlePositions (pack, dbContext, pack.State, pack.AccountUID.Value, mappedSecurity, pack.StatementDate.Value);

secGuidsWithPositions.Add (mappedSecurity.SecurityGuid.Value);

mappedSecurity.Postitions = updatedPositions! = null && updatedPositions.Count ()> 0
? aktualisiertePositionen
: new position[0];

if (updatedPositions! = null && updatedPositions.Count ()> 0)
hasModifications = true;
}

// EditTransaction
TRANSACTION[] updatedTransactions = null;
if (mappedSecurity.Transactions! = null && mappedSecurity.Transactions.Length> 0)
{

mappedSecurity.Transactions = updatedTransactions! = null && updatedTransactions.Count ()> 0
? aktualisierteTransactions
: new TRANSACTION[0];

if (updatedTransactions! = null && updatedTransactions.Count ()> 0)
hasModifications = true;
}
}
}

if (! hasErrors && dbContext.ChangeTracker.HasChanges ())
{
To attempt
{

await dbContext.SaveChangesAsync ();


}
catch (exception ex)
{
waitit Logger.Send (pack, LogType.Warning, "Error changing db, reset:" + ex.ToString ());
throw new LoggedException ();
}
}
}

Return pack;
} 

Here are my three functions calling the above method – here are many slowdowns:

                private async task TryFindSecId (AccMappedSecurity mappedSecurity, long firmId, newportMasterContext dbContext, Guid? PackUid = null)
{

var existsSecurities = dbContext.SEC_IDENTIFIER
.Where (x => x.IdentifierName == mappedSecurity.IdentifierName
&& mappedSecurity.IdentifierValue == x.Identifier
&& x.FirmID == firmId
&& (string.IsNullOrEmpty (mappedSecurity.Currency) || x.SECURITY.Currency == mappedSecurity.Currency) && x.SECURITY.ChangeType! = "D");

var existsSecurity = existsSecurities.FirstOrDefault ();

if (existsSecurity == null)
{
var cloneResult = ClonePostition.Clone expect (
new ClonePositionRequest
{
IdentifierName = mappedSecurity.IdentifierName,
IdentifierValue = mappedSecurity.IdentifierValue,
NewCurrency = mappedSecurity.Currency,
FirmId = FirmId
},
Logger.LocalLog
);



if (cloneResult.Code! = HttpStatusCode.InternalServerError)
{
existsSecurity = dbContext.SEC_IDENTIFIER
.FirstOrDefault (x => x.IdentifierName == mappedSecurity.IdentifierName)
&& mappedSecurity.IdentifierValue == x.Identifier
&& x.FirmID == firmId
&& (string.IsNullOrEmpty (mappedSecurity.Currency) || x.SECURITY.Currency == mappedSecurity.Currency));


}
otherwise
{
waitit Logger.Send (LogType.Error, "Internal server error on clone function - clone failed" + cloneResult.Code);
}


}
otherwise
{

}

return existing security;
}





private location[] HandlePositions (AccPackBody reqPayload, newportMasterContext dbContext, Status PackState, Guid accountGuid, AccMappedSecurity mappedSecurity, DateTime statementDate, Guid? PackUid = null)
{
if (useDiagnosticLogging) LocalLoggingUtilities.WriteDiagnosticLog (_logText, packUid.Value, "hit handle positions");

var handlePositions = new list();
int posCnt = mappedSecurity.Postitions.Length;
if (useDiagnosticLogging) LocalLoggingUtilities.WriteDiagnosticLog (_logText, packUid.Value, "Deserialization of assigned positions");
list deserializedPosition = mappedSecurity.Postitions
.Select (x => JsonConvert.DeserializeObject(x.ToString (), Configs.JsonCircularRefFixConfig))
.OrderBy (x => x.DateStart)
.List();

var updatedPosDetails = new list();
POSITION prevailing position = zero;

if (useDiagnosticLogging) LocalLoggingUtilities.WriteDiagnosticLog (_logText, packUid.Value, "Check for prevailing position.");

prevailingPosition = dbContext.POSITION
.Include (x => x.POSITION_DETAIL)
.Include (x => x.POSITION_DETAIL) .ThinInclude (x => x.POSITION_BOND)
.Include (x => x.POSITION_DETAIL) .ThinInclude (x => x.POSITION_FX)
.Include (x => x.POSITION_DETAIL) .ThinInclude (x => x.POSITION_OPTION)
.Include (x => x.POSITION_DETAIL) .ThinInclude (x => x.POSITION_PRICE)
.Where (x => x.Account_UID == accountGuid
&& x.Security_UID == mappedSecurity.SecurityGuid
&& x.SecurityFirmID == mappedSecurity.FirmId
&& (x.DateStart.Date <= statementDate) && (! x.DateEnd.HasValue || x.DateEnd.Value.Date < statementDate) 
                && x.ChangeType != "D" 
                && x.POSITION_DETAIL.Any(pd => pd.Genesis == "FEED" &&
pd.ChangeType! = "D"))
.OrderByDescending (x => x.DateStart)
.ToList (). FirstOrDefault ();

if (useDiagnosticLogging) LocalLoggingUtilities.WriteDiagnosticLog (_logText, packUid.Value, "Looping Inbound Positions.");
foreach (var incomingPosition in deserializedPositions)
{
if (useDiagnosticLogging) LocalLoggingUtilities.WriteDiagnosticLog (_logText, packUid.Value, string.Format ("Take new incoming position: {0}"), incomingPosition.Position_UID.ToString ());
incomingPosition.Account_UID = accountGuid;
incomingPosition.Security_UID = mappedSecurity.SecurityGuid.Value;
incomingPosition.SecurityFirmID = mappedSecurity.FirmId.Value;
incomingPosition.Position_UID = Guid.NewGuid ();
if (prevailingposition == null)
{
EntityEntry newPosition = null;
dbContext.POSITION.Add (incomingPosition);
newPosition = dbContext.Entry (incomingPosition);
newPosition.CurrentValues.SetValues ​​(new {ChangeType = "I"});
foreach (var posDetail in incomingPosition.POSITION_DETAIL.Where (x => x.ChangeType.ToUpper ()! = "D"))
{
EntityEntry newPositionDetail = null;
posDetail.Detail_UID = Guid.NewGuid ();
dbContext.POSITION_DETAIL.Add (posDetail);
newPositionDetail = dbContext.Entry (posDetail);
newPositionDetail.CurrentValues.SetValues ​​(new {ChangeType = "I"});
updatedPosDetails.Add (posDetail);
}

managedPositions.Add (incomingPosition);

if (useDiagnosticLogging) LocalLoggingUtilities.WriteDiagnosticLog (_logText, packUid.Value, "Inserted:") + incomingPosition.Position_UID.ToString ());
}
otherwise
{
if (prevailingPosition.DateStart.Date == incomingPosition.DateStart.Date)
{
foreach (var posDetail in prevailingposition.POSITION_DETAIL.Where (x => x.ChangeType.ToUpper ()! = "D"))
{
EntityEntry positionDetailToRemove = dbContext.Entry (posDetail);
positionDetailToRemove.CurrentValues.SetValues ​​(new)
{
ChangeDate = DateTime.Now,
ChangeType = "D"
});
}
EntityEntry positionToRemove = dbContext.Entry (prevailing position);
positionToRemove.CurrentValues.SetValues ​​(new)
{
ChangeDate = DateTime.Now,
ChangeType = "D"
});

EntityEntry newPosition = null;
dbContext.POSITION.Add (incomingPosition);
newPosition = dbContext.Entry (incomingPosition);
newPosition.CurrentValues.SetValues ​​(new {ChangeType = "I"});
managedPositions.Add (incomingPosition);

if (useDiagnosticLogging) LocalLoggingUtilities.WriteDiagnosticLog (_logText, packUid.Value, "insert:" + incomingPosition.Position_UID.ToString ());

foreach (var posDetail in incomingPosition.POSITION_DETAIL.Where (x => x.ChangeType.ToUpper ()! = "D"))
{
EntityEntry newPositionDetail = null;
posDetail.Detail_UID = Guid.NewGuid ();
dbContext.POSITION_DETAIL.Add (posDetail);
newPositionDetail = dbContext.Entry (posDetail);
newPositionDetail.CurrentValues.SetValues ​​(new {ChangeType = "I"});
updatedPosDetails.Add (posDetail);
}
}
else if (prevailingPosition.DateStart.Date <incomingPosition.DateStart.Date.)
&& PositionHasChange (prevailingposition, incomingPosition, packUid))
{
EntityEntry newPosition = null;
dbContext.POSITION.Add (incomingPosition);
newPosition = dbContext.Entry (incomingPosition);
newPosition.CurrentValues.SetValues ​​(new {ChangeType = "I"});
managedPositions.Add (incomingPosition);

if (useDiagnosticLogging) LocalLoggingUtilities.WriteDiagnosticLog (_logText, packUid.Value, "insert:" + incomingPosition.Position_UID.ToString ());

foreach (var posDetail in incomingPosition.POSITION_DETAIL.Where (x => x.ChangeType.ToUpper ()! = "D"))
{
EntityEntry newPositionDetail = null;
posDetail.Detail_UID = Guid.NewGuid ();
dbContext.POSITION_DETAIL.Add (posDetail);
newPositionDetail = dbContext.Entry (posDetail);
newPositionDetail.CurrentValues.SetValues ​​(new {ChangeType = "I"});
updatedPosDetails.Add (posDetail);
}
}
else if (prevailingPosition.DateStart.Date <incomingPosition.DateStart.Date.)
&&! PositionHasChange (prevailing position, incomingPosition, packUid))
{
}
}
}

return donePositions.ToArray ();
}





private transaction[] HandleTransctions (newportMasterContext dbContext, AccPackBody package, AccMappedSecurity mappedSecurity, Guid? PackUid = null)
{
object[] transactionToProcess = new object[0];
var managedTransactions = new list();

foreach (var trans in mappedSecurity.Transactions)
{
TRANSACTION managedTransaction = null,
mappedTransaction = null;

mappedTransaction = JsonConvert.DeserializeObject(trans.ToString (), Configs.JsonCircularRefFixConfig);
mappedTransaction.Security_UID = mappedSecurity.SecurityGuid.Value;

//CHOP
if (string.IsNullOrWhiteSpace (mappedTransaction.BaseCurrency))
{
mappedTransaction.BaseCurrency = "USD";
}

// missing transId - drop out
if (mappedTransaction.Reversal && string.IsNullOrWhiteSpace (mappedTransaction.TranID))
{
Logger.Send (pack, LogType.Warning, "Cancellation transaction missing a transaction ID");
throw new LoggedException ();
}
otherwise
{
//if(mappedTransaction.Reversal &&! string.IsNullOrWhiteSpace (mappedTransaction.TranID))
if (mappedTransaction.Reversal)
{
list transactionInDb = dbContext.TRANSACTION
.Where (x => x.Account_UID == pack.AccountUID
&& x.Security_UID == mappedSecurity.SecurityGuid
&& x.SecurityFirmID == mappedSecurity.FirmId
&& x.TradeDate.Date == mappedTransaction.TradeDate.Date
&& x.TranID == mappedTransaction.TranID
&&! x.Reversal
&& x.ChangeType! = "D")
.List();

if (transactionInDb.Count == 1)
{
mappedTransaction.Visible = false;
TRANSACTION transactionInDb = transactionInDb.FirstOrDefault ();
transactionInDb.Visible = false;
}
}

mappedTransaction.SecurityFirmID = mappedSecurity.FirmId.Value;
mappedTransaction.Account_UID = pack.AccountUID.Value;

if (mappedTransaction? .Comment? .Length> = 100)
{
mappedTransaction.Comment = mappedTransaction.Comment.Substring (0,96) + "...";
}

mappedTransaction.Tran_UID = Guid.NewGuid ();

var comparer = new TransactionComparer ();
EntityEntry transactionToInsert = null;
dbContext.TRANSACTION.Add (mappedTransaction);
transactionToInsert = dbContext.Entry (mappedTransaction);
transactionToInsert.CurrentValues.SetValues ​​(new {ChangeType = "I"});

if (useDiagnosticLogging) LocalLoggingUtilities.WriteDiagnosticLog (_logText, packUid.Value, "inserted:" + mappedTransaction.Tran_UID.ToString ());

if (transactionToInsert! = null)
{
transactionToInsert.CurrentValues.SetValues ​​(new {ChangeDate = DateTime.Now});
}

chargedTransaction = transactionToInsert? .Entity;

if (handlingTransaction! = null)
{
managedTransactions.Add (managedTransaction);
}
//}
}



}

return doneTransactions.ToArray ();
}

Example Payload:

{
"id": "74a7c410-5b00-4268-bb40-73cf099160ff",
"custodianUid": "00000000-0000-0000-0000-000000000000",
"datasourceUid": "e4b30a37-d0bf-49d4-bee9-a0cc19959e6d",
"token": "@ !!! @ ec131ebc7537c0f8414447261af2a8ef28414815274ebd4ea0ba33caac231bc8",
"statementDate": "2019-01-07T00: 00: 00Z",
"accountUid": "0b251123-b9e5-4f59-be4d-4dde0f0eb23e",
"firmId": 490
"Condition": 3,
"oversSizeLimit": false,
"external":[
{
"Identifier value": "85280",
"IdentifierName": "AssetID",
"Currency: USD",
"firmId": null,
"batchid": zero,
"securityGuid": null,
"previousPositionGuid": "57b63479-9cc1-49b3-9743-8932b1764d1e",
"previousPositionQty": 1000000
"previousPositionStartDate": "2019-01-01T00: 00: 00 + 00: 00",
"previousPositionEndDate": null,
"Transactions": [],
"Taxlots": [],
"Positions": [
        "1/7/2019 12:00:00 AM|TAA0315||@!!!@ec131ebc7537c0f8414447261af2a8ef28414815274ebd4ea0ba33caac231bc8|Security|Structured Product|85280|0|||||||||0.0000|0.0000||0|0|||0.00000|||1000000.00000|100.00|100.00|84.18000|84.18000|6/8/2021 12:00:00 AM|0.00||0.00|0.00|||841800.00|841800.00|USD|||||0.0000||||||||"
      ],
"Inch": []
    },
{
"Identifier value": "79428",
"IdentifierName": "AssetID",
"Currency: USD",
"firmId": null,
"batchid": zero,
"securityGuid": null,
"previousPositionGuid": "238c6c1e-0815-4b74-8ac8-d695ddb5ff2e",
"previous Position Qty": 1500000,
"previousPositionStartDate": "2019-01-01T00: 00: 00 + 00: 00",
"previousPositionEndDate": null,
"Transactions": [],
"Taxlots": [],
"Positions": [
        "1/7/2019 12:00:00 AM|TAA0315||@!!!@ec131ebc7537c0f8414447261af2a8ef28414815274ebd4ea0ba33caac231bc8|Security|Structured Product|79428|0|||||||||0.0000|0.0000||0|0|||0.00000|||1500000.00000|100.00|100.00|95.31000|95.31000|1/22/2021 12:00:00 AM|0.00||0.00|0.00|||1429650.00|1429650.00|USD|||||0.0000||||||||"
      ],
"Inch": []
    }
],
"Internal": [
    {
      "_name": null,
      "data": null,
      "identifiervalue": "85280",
      "identifierName": "AssetID",
      "currency": "USD",
      "previousPositionGuid": null,
      "previousPositionQty": null,
      "previousPositionStartDate": null,
      "previousPositionEndDate": null,
      "securityGuid": "c260432b-d169-474b-b142-83cd3e2b93e5",
      "firmId": 490,
      "positions": [
        {
          "Position_UID": "1e6b6a39-697a-468b-a266-bd5388475ec6",
          "Account_UID": "0b251123-b9e5-4f59-be4d-4dde0f0eb23e",
          "Security_UID": "c260432b-d169-474b-b142-83cd3e2b93e5",
          "SecurityFirmID": 490,
          "DateStart": "2019-01-07T00:00:00+00:00",
          "DateEnd": null,
          "ChangeDate": "2019-04-16T15:40:39.7454448Z",
          "ChangeType": "I",
          "BatchID": 2019416151243529,
          "Account_U": null,
          "Security": null,
          "POSITION_DETAIL": [
            {
              "Detail_UID": "39048278-f993-4229-b596-c681315c46b1",
              "Position_UID": "1e6b6a39-697a-468b-a266-bd5388475ec6",
              "Type": "BASE",
              "Quantity": 1000000,
              "Currency": "USD",
              "Value": 841800,
              "LastPrice": 84.18,
              "Cost": 100,
              "AccruedInterest": 0,
              "AccruedDividends": null,
              "Expenses": null,
              "UnrealizedGains": null,
              "RealizedGains": null,
              "Source_UID": "e4b30a37-d0bf-49d4-bee9-a0cc19959e6d",
              "Genesis": "Feed",
              "ChangeDate": "2019-04-16T15:40:39.8235573Z",
              "ChangeType": "I",
              "GenesisNavigation": null,
              "TypeNavigation": null,
              "POSITION_BOND": null,
              "POSITION_FX": null,
              "POSITION_OPTION": null,
              "POSITION_PRICE": null
            }
          ],
"POSITION_IDENTIFIER": [],
"POSITION_SUBSCRIPTION": []
        }
],
"transactions": zero,
"batchid": zero
},
{
"_name": null,
"data": zero,
"Identifier value": "79428",
"IdentifierName": "AssetID",
"Currency: USD",
"previousPositionGuid": null,
"previousPositionQty": zero,
"previousPositionStartDate": null,
"previousPositionEndDate": null,
"securityGuid": "266a3cc3-9f76-4ca1-a1bb-593c55d86e95",
"firmId": 490
"Positions": [
        {
          "Position_UID": "4d2e6c40-6878-4fab-96df-d62759e95917",
          "Account_UID": "0b251123-b9e5-4f59-be4d-4dde0f0eb23e",
          "Security_UID": "266a3cc3-9f76-4ca1-a1bb-593c55d86e95",
          "SecurityFirmID": 490,
          "DateStart": "2019-01-07T00:00:00+00:00",
          "DateEnd": null,
          "ChangeDate": "2019-04-16T15:40:39.870434Z",
          "ChangeType": "I",
          "BatchID": 2019416151243529,
          "Account_U": null,
          "Security": null,
          "POSITION_DETAIL": [
            {
              "Detail_UID": "c894765d-482a-4649-87be-afc6c8092275",
              "Position_UID": "4d2e6c40-6878-4fab-96df-d62759e95917",
              "Type": "BASE",
              "Quantity": 1500000,
              "Currency": "USD",
              "Value": 1429650,
              "LastPrice": 95.31,
              "Cost": 100,
              "AccruedInterest": 0,
              "AccruedDividends": null,
              "Expenses": null,
              "UnrealizedGains": null,
              "RealizedGains": null,
              "Source_UID": "e4b30a37-d0bf-49d4-bee9-a0cc19959e6d",
              "Genesis": "Feed",
              "ChangeDate": "2019-04-16T15:40:39.9798084Z",
              "ChangeType": "I",
              "GenesisNavigation": null,
              "TypeNavigation": null,
              "POSITION_BOND": null,
              "POSITION_FX": null,
              "POSITION_OPTION": null,
              "POSITION_PRICE": null
            }
          ],
"POSITION_IDENTIFIER": [],
"POSITION_SUBSCRIPTION": []
        }
],
"transactions": zero,
"batchid": zero
}
],
"batchid": 2019416151243529
}

Objective – do I see enough improvements from EF-S to "L" lenses to ensure the cost?

Will I really see better photos to guarantee the cost?

Honestly, probably not. Recording better photos has much more to do with the knowledge, experience and creative eye of the photographer than with the slight differences between comparably good lenses or camera bodies.

If you can not explain what your current two lenses are, that limit the ability to create the photos, you might want the slightly better optical quality and slightly faster maximum apertures probably no real improvements to your photos. In fact, if you know the limitations and know how to handle them, if you use larger apertures, you might get pictures that are not as good as you could do with your two current lenses.

The key benefits of the three "L" lenses you are considering are durability and resistance to adverse environmental conditions. These features are crucial for working professionals who put their equipment through the Wringer every day. Yes, they are visually a little better than your current lenses. Their "sweet spots" are larger in terms of the focal lengths and openings, where they occur at a slightly higher level. However, in terms of optical performance, they are much closer to the current lenses than to the true premium lenses in each category, e.g. B. EF 11-24 mm 1: 4L, EF 24 – 70 mm 1: 2,8L II or EF 70 -200 mm 1: 2,8L IS II. Even these lenses only make a noticeable difference when used with or used near open openings. At f / 5.6 or f / 8, there is little difference in the optical world.

If you really have more options for taking pictures on vacation that you can not achieve with your current lenses, consider an ultra wide-angle lens such as the EF-S 10-22mm f / 3.5-4.5 , That would only be good if you are interested in taking in the current 15-85mm wider views.

All these years, I wish I had quality L-glass … Because, as someone said, there's a lot in the eye. I feel like I have that. I shoot only in manual mode and search for the color bangs … Sharp scenes that I suspect come with "good glass".

There is nothing "magic" about L-glass. For example, the EF-S 17-55 mm 1: 2.8 IS in a crop sensor is optically about 24 mm better than the EF 16-35 mm 1: 2.8L II. It is also almost the optical equivalent to the original EF 24-70mm 1: 2,8L, with the "L" on a FF body and the 17-55mm on one of the newer grain cultures. The newer 24-70mm is optically much better, from 24mm to 70mm at each aperture, even with the wider aperture, as the newer high-resolution cameras revealed the shortcomings of the older 24-70mm.

For f / 5.6-f / 8-f / 11 apertures, which are used for most landscape shots, virtually all current Canon, Nikon, Sony, Pentax, etc. lenses are very good throughout the image, assuming They are in the right orientation and have developed a flat field. There are some very expensive lenses that have been developed for specific uses and leave the field curvature uncorrected. That's one of the things that make the EF 85mm 1: 1,2L a "portrait lens" with such a unique look. Such a lens, while costing thousands of dollars, is not a suitable lens for most landscape work.

I suspect this Farbrausch sharp scenes It's more about catching the right quality light at the right angle with a camera mounted on a stone tripod. I know many landscape photographers who drive to the same spot every day until they finally get the light they want. One day it may be too cloudy. The next day there may be too much or too little moisture or dust in the air. It could rain the next day. Just because you're standing in the same spot from which an iconic photo was taken does not mean that you always have the same light, even if you have the same angle of the sun. Nothing compares to the light coming from a low sun in the late afternoon, after a storm has just passed over us and the sky in the west becomes clearer. The light is so saturated and golden that you can do it practically feeling Its warmth immerses everything in Technicolor and makes the world look like a Kodachrome slide. The same place at the same time of day the day before or the day after can look flat and lifeless under a comforting sky.

In the digital age, we can "fix" the light in the inbox much easier and with a larger width than in the color dark room, but we still can not move the sun from one point in the sky to another.

Here's my suggestion: For the next few weeks, you should travel at the same time every day at the same time with camera, tripod and cable release to the most scenic spot in your area. If the sun is most favorable for your chosen location, probably go in the early morning or late afternoon. Make the most of what you can do with the tripod and cable release. If the shutter speed is less than 1/200 seconds, also use the mirror lock. On even days, use your 15-85 between 55-85 mm. On odd days use the 55-250 mm between 55 and 85 mm. If you have a 50mm 1: 1.8 lens or other main lens, also throw it into the mix. At the end of the two weeks, edit the best shot of each day and compare the 14 photos. Let us know what you think about the 14 photos and how they compare with the others.

There is an old saying that has existed for a long time: Gear does not matter
That's really only half the story.
The full truth is: Gear does not matter – until it works.

When the limits of your equipment really start to grow in importance and where you work as a photographer, you know it.

P.S.- The reason why the 16-35mm f / 4 gets better reviews is if you do not really, really, really need the f / 2.8 lens for moving objects in low light is the f / 4 lens good or even better for all f / 4 f-stops. And it's cheaper to boot.

What Animal Improvements Can a Simic Hybrid Druid Keep on Wild Shaped?

What Animal Improvements Can a Simic Hybrid Druid Keep on Wild Shaped?
Manta Glide, nimble climber, underwater adaptation, lifting attachment, carapace and / or acid spit?

Does the type of beast that I am working on Wild Shape determine, if I can keep a certain animal improvement? For example, if I wanted to make a wild crab, would I keep my trailer attachment feature? What if I wildly turn into a bear?

Alert improvements from Xon | NulledTeam UnderGround

A collection of enhancements to the XenForo Alerts system.

This add-on requires php 5.6 or newer

properties

  • For thread / conversation / profile pages, automatically flags warnings when they are read as content on a particular page.
  • Highlight the unread link for individual alerts on the Alerts page.
  • Supports the following add-ons:
  • Global Optional, alert summary by selected content type or user
  • User option to prevent marking as read …

Report improvements from Xon | NulledTeam UnderGround

Screenshots still need to be added, the XF1 version has similar features and the screenshots

This add-on may change changes to moderation permissions. You're welcome review User group permissions carefully!

A collection of improvements to the reporting system of XF. Fully formulated.

During installation, all existing alerts are copied to a new log change log and linked to reports. This process acts as a background task and is …

Mobile app development tool – Apache Cordova

To modernize legacy systems or bring scalable internal or customer-oriented apps to market at the right time, I recommend that you immediately jump to my cross-platform enterprise mobile development guide.
It includes open source tools and free, cross-platform mobile app development tools that any developer can instantly enjoy.
Apache Cordova

Apache Cordova tops this list because it supports the design process for most free cross-platform mobile application development tools, and many that are not free. Previously known as Phone Gap, Adobe released Cordova as an open source project that has received contributions from BlackBerry, Google, IBM, Intel and Microsoft at this time.

By embedding web code in a native Cordova package, Cordova provides access to native APIs. By incorporating community plugins, apps can connect to any number of these APIs using simple JavaScript.

Pros:

Cut out the middleman. By working directly with Cordova, developers have access to the latest updates from the Apache team. With each release, Cordova gets access to critical operating system improvements. These enhancements can improve Cordova's performance and give it access to new APIs. Build directly on Cordova and you will never miss it.

Disadvantage:

Cordova is UI and Framework Agnostic. It leaves the designer all design and architecture decisions. This may not be a problem if you have previously created mobile-first websites. However, if you're working on a mobile application for the first time, consider using a framework that will do a little more with your hands. According to the developer survey by Stack Overflow, the developers are particularly concerned about working with Cordova.

,

Python – Possible improvements for data transformation with dictionaries and lists

My initial problem is one list from mappings are their values lists of values. The converted list must contain the Cartesian product of all lists (those that are values ​​in the dictionaries) that belong to separate dictionaries (in other words, the values ​​of the lists in the same directories are "coupled").

If you ignore the keywords in the dictionaries, this is easily solved itertools.product,

Entrance:

[
   {
      ('B3G', 'B1'): [1.0, 2.0],
("B1G", "B1"): [11.0, 12.0]
   },
{
("B2G", "B1"): [1.5, 2.5, 3.5]
   }
]

Output:

[
  {('B3G', 'B1'): 1.0, ('B1G', 'B1'): 11.0, ('B2G', 'B1'): 1.5},
  {('B3G', 'B1'): 1.0, ('B1G', 'B1'): 11.0, ('B2G', 'B1'): 2.5},
  {('B3G', 'B1'): 1.0, ('B1G', 'B1'): 11.0, ('B2G', 'B1'): 3.5},
  {('B3G', 'B1'): 2.0, ('B1G', 'B1'): 12.0, ('B2G', 'B1'): 1.5},
  {('B3G', 'B1'): 2.0, ('B1G', 'B1'): 12.0, ('B2G', 'B1'): 2.5},
  {('B3G', 'B1'): 2.0, ('B1G', 'B1'): 12.0, ('B2G', 'B1'): 3.5}
]

To make things even more confusing, the keywords are the individual dictionaries tuples of strings.

Here is one possible implementation with one class isolate the whole mess.

@dataclass
Class ParametricMapping:
"" Abstraction for multidimensional parametric mappings. " ""

Assignments: List[Mapping[Tuple[str], Sequence[float]]]= Field (default_factory = lambda: [{}])

@Property
def combinations (self) -> list[Mapping[Tuple[str]swim]]:
"" "Cartesian product suitable for working with dictionaries, much like 'itertools.product`." ""

labels = [label for arg in self.mappings for label in tuple(arg.keys())]
    Pools = [list(map(tuple, zip(*arg.values()))) for arg in self.mappings]

    def cartesian_product (* args):
"" "Cartesian product similar to" itertools.product "" ""
Result = [[]]for pool in args:
Result = [x + [y] for x as a result for y in the pool]Return result

Results []
    for term in cartesian_product (* Pools):
results.append ([pp for p in term for pp in p])

tmp = []
    for r in results:
tmp.append ({k: v for k, v in zip (labels, r)})

if len (tmp) == 0:
return [{}]
    otherwise:
Return tmp

question: How can I improve that to make it cleaner (priority # 1) and faster (# 2).

content structure

BlackHatKings: Content / Copywriting
Published by: Anyon
Post-Time: December 31, 2018 at 08:20.

Search for improvements | NulledTeam UnderGround

A collection of XF advanced search enhancements and some for XenForo's default MySQL search.

MySQL & Elastic Search functions;

  • range_query looking for DSL
    • allows any range queries for numeric data
  • Allow users to select the default search order regardless of the forum-wide setting.

Only for the elastic search:

  • Weighting by content type
  • Adds information about the elastic search to the AdminCP startup screen.
  • Adds a debug option to …